#include <iostream>
#include <vector>
#include <queue>
using namespace std;

/*
题目：迷宫最短路（BFS）
解题思路：
- 用一维vector<char>存储迷宫，避免嵌套vector，节省空间，适合初学者。
- 采用广度优先搜索（BFS）算法，从起点'@'出发，按层扩展，遇到终点'*'时返回步数。
- 用一维vector<bool>记录每个格子是否访问过，防止重复走回头路。
- 每次扩展四个方向（上下左右），遇到'#'为墙不可走。
- 若无法到达终点，返回-1。
- 主函数负责输入、数据准备和输出，BFS主逻辑封装为bfs函数，便于复用。
*/

// 封装BFS主逻辑为函数，返回最短步数，找不到返回-1
int bfs(const vector<char>& grid, int M, int N, int sx, int sy) {
    vector<bool> vis(M * N, false); // 访问标记数组，初始全为false
    queue<pair<int, int>> q;        // 队列存储待扩展的坐标
    q.push({sx, sy});               // 起点入队
    vis[sx * N + sy] = true;        // 标记起点已访问
    int dx[4] = {-1, 1, 0, 0};      // 上下左右四个方向的行偏移
    int dy[4] = {0, 0, -1, 1};      // 上下左右四个方向的列偏移
    int step = 0;                   // 当前步数
    while (!q.empty()) {
        int size = q.size();        // 当前层的节点数
        for (int i = 0; i < size; ++i) {
            int x = q.front().first;
            int y = q.front().second;
            q.pop();
            if (grid[x * N + y] == '*') return step; // 找到终点，返回步数
            for (int d = 0; d < 4; ++d) {            // 扩展四个方向
                int nx = x + dx[d];
                int ny = y + dy[d];
                // 判断新坐标是否在范围内、未访问且不是墙
                if (nx >= 0 && nx < M && ny >= 0 && ny < N && !vis[nx * N + ny] && grid[nx * N + ny] != '#') {
                    vis[nx * N + ny] = true;         // 标记已访问
                    q.push({nx, ny});                // 新坐标入队
                }
            }
        }
        step++; // 扩展完一层，步数加1
    }
    return -1; // 无法到达终点，返回-1
}

int main() {
    int M, N;
    // 支持多组输入，直到输入0 0结束
    while (cin >> M >> N && (M != 0 || N != 0)) {
        vector<char> grid;
        grid.resize(M * N); // 迷宫用一维数组存储
        int sx = -1, sy = -1; // 起点坐标
        for (int i = 0; i < M; ++i) {
            for (int j = 0; j < N; ++j) {
                char ch;
                cin >> ch;
                grid[i * N + j] = ch; // 存储到一维数组
                if (ch == '@') {      // 记录起点坐标
                    sx = i;
                    sy = j;
                }
            }
        }
        if (sx == -1) { // 没有起点，直接输出-1
            cout << -1 << endl;
            continue;
        }
        int ans = bfs(grid, M, N, sx, sy); // 调用BFS函数求最短路
        cout << ans << endl; // 输出结果
    }
    return 0;
}